Implement HPX Future-Sender Bridge (P2300 interoperability) - #7256

libs/core/futures/include/hpx/futures/future_sender.hpp (1)

21-27: 🩺 Stability & Availability | 🔵 Trivial | ⚡ Quick win

Add a direct include for try_catch_exception_ptr.

hpx::detail::try_catch_exception_ptr is used in start_helper (Lines 82, 89, 153, 156) but this header only includes config/future/execution_base and relies on a transitive include. sender_future.hpp correctly pulls in <hpx/modules/errors.hpp>; add it here too to avoid a fragile dependency.

♻️ Suggested include

 `#include` <hpx/config.hpp>
 `#include` <hpx/futures/future.hpp>
+#include <hpx/modules/errors.hpp>
 `#include` <hpx/modules/execution_base.hpp>

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@libs/core/futures/include/hpx/futures/future_sender.hpp` around lines 21 -
27, The header for future_sender uses hpx::detail::try_catch_exception_ptr in
start_helper but does not include the header that declares it, relying on a
transitive dependency. Update future_sender.hpp to add the direct include for
hpx/modules/errors.hpp alongside the existing HPX includes so start_helper is
self-contained and no longer depends on indirect includes.

Fix all unresolved CodeRabbit comments on this PR:

• Push a commit to this branch (recommended)
• Create a new PR with the fixes

libs/core/execution/tests/unit/future_sender_test.cpp (1)

122-141: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Good addition for shared_future copyability, but consider covering void result types too.

This test exercises shared_future<int>, but the PR history notes CI failures were specifically caused by incompatible completion signatures for future<void> and shared_future<int>. Adding a future<void>/shared_future<void> round-trip test here would directly guard against regressing that exact fix.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@libs/core/execution/tests/unit/future_sender_test.cpp` around lines 122 -
141, Add a void-result round-trip test alongside
test_shared_future_copyable_semantics, covering both future<void> and
shared_future<void> through as_sender and sync_wait. Verify the sender pipeline
completes successfully without requiring a value, directly guarding compatible
completion signatures while preserving the existing int copyability assertions.

libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp (1)

26-121: 📐 Maintainability & Code Quality | 🔵 Trivial | ⚡ Quick win

Remove the obsolete sender wrappers as_sender_t now constructs detail::future_sender / detail::future_sender_with_scheduler, and as_sender_sender_with_scheduler still routes through the legacy as_sender_operation_state. These detail types are only referenced here, so the old wrapper can go with the other obsolete implementation.

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@libs/core/execution/include/hpx/execution/algorithms/as_sender.hpp` around
lines 26 - 121, Remove the obsolete as_sender_operation_state class and its
related implementation from this header, since as_sender_t now uses
detail::future_sender and detail::future_sender_with_scheduler while
as_sender_sender_with_scheduler should no longer depend on the legacy state.
Clean up any now-unused declarations or references tied exclusively to this
wrapper.

libs/core/execution/tests/unit/future_sender_test.cpp (1)

185-200: 📐 Maintainability & Code Quality | 🔵 Trivial | 💤 Low value

Verify copyability by asserting or explicitly copying the sender.

The test's stated goal is to verify that the shared_future path remains copyable. However, the current code moves snd into sync_wait without ever evaluating its copy semantics, which leaves the copyability unverified.

Consider adding a compile-time assertion and explicitly copying the sender to validate its copyability.

♻️ Proposed refactor to test copyability

 void test_as_sender_with_scheduler_shared_future()
 {
     ex::thread_pool_scheduler sched{};
     hpx::shared_future<int> f = hpx::make_ready_future(13);
 
     auto snd = ex::as_sender(f, sched);
+    static_assert(std::is_copy_constructible_v<decltype(snd)>);
+    auto snd_copy = snd;
+
     auto result =
-        tt::sync_wait(std::move(snd) | ex::then([](int x) { return x + 1; }));
+        tt::sync_wait(std::move(snd_copy) | ex::then([](int x) { return x + 1; }));
 
     HPX_TEST(result.has_value());
     HPX_TEST_EQ(std::get<0>(*result), 14);
 }

🤖 Prompt for AI Agents

Verify each finding against current code. Fix only still-valid issues, skip the
rest with a brief reason, keep changes minimal, and validate.

In `@libs/core/execution/tests/unit/future_sender_test.cpp` around lines 185 -
200, Update test_as_sender_with_scheduler_shared_future to verify the sender’s
copyability explicitly: add a compile-time copyability assertion for the sender
type and create a copied sender before invoking sync_wait, while preserving the
existing result validation.